/*
 * contrib/spi/refint.c
 *
 *
 * refint.c --	set of functions to define referential integrity
 *		constraints using general triggers.
 */
#include "postgres.h"
#include "knl/knl_variable.h"

#include <ctype.h>

#include "commands/trigger.h"
#include "executor/spi.h"
#include "utils/builtins.h"
#include "utils/rel.h"
#include "utils/rel_gs.h"
#include "knl/knl_instance.h"

PG_MODULE_MAGIC;

extern "C" Datum check_primary_key(PG_FUNCTION_ARGS);
extern "C" Datum check_foreign_key(PG_FUNCTION_ARGS);

static EPlanRefInt* find_plan(char* ident, EPlanRefInt** eplan, int* nplans);

/*
 * check_primary_key () -- check that key in tuple being inserted/updated
 *			 references existing tuple in "primary" table.
 * Though it's called without args You have to specify referenced
 * table/keys while creating trigger:  key field names in triggered table,
 * referenced table name, referenced key field names:
 * EXECUTE PROCEDURE
 * check_primary_key ('Fkey1', 'Fkey2', 'Ptable', 'Pkey1', 'Pkey2').
 */

PG_FUNCTION_INFO_V1(check_primary_key);

Datum check_primary_key(PG_FUNCTION_ARGS)
{
    TriggerData* trigdata = (TriggerData*)fcinfo->context;
    Trigger* trigger = NULL;     /* to get trigger name */
    int nargs;                   /* # of args specified in CREATE TRIGGER */
    char** args;                 /* arguments: column names and table name */
    int nkeys;                   /* # of key columns (= nargs / 2) */
    Datum* kvals = NULL;         /* key values */
    char* relname = NULL;        /* referenced relation name */
    Relation rel;                /* triggered relation */
    HeapTuple tuple = NULL;      /* tuple to return */
    TupleDesc tupdesc;           /* tuple description */
    EPlanRefInt* plan = NULL;          /* prepared plan */
    Oid* argtypes = NULL;        /* key types to prepare execution plan */
    bool isnull = false;         /* to know is some column NULL or not */
    char ident[2 * NAMEDATALEN]; /* to identify myself */
    int ret;
    int i;

#ifdef DEBUG_QUERY
    elog(DEBUG4, "check_primary_key: Enter Function");
#endif

    /*
     * Some checks first...
     */

    /* Called by trigger manager ? */
    if (!CALLED_AS_TRIGGER(fcinfo))
        /* internal error */
        elog(ERROR, "check_primary_key: not fired by trigger manager");

    /* Should be called for ROW trigger */
    if (!TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
        /* internal error */
        elog(ERROR, "check_primary_key: must be fired for row");

    /* If INSERTion then must check Tuple to being inserted */
    if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
        tuple = trigdata->tg_trigtuple;

    /* Not should be called for DELETE */
    else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
        /* internal error */
        elog(ERROR, "check_primary_key: cannot process DELETE events");

    /* If UPDATion the must check new Tuple, not old one */
    else
        tuple = trigdata->tg_newtuple;

    trigger = trigdata->tg_trigger;
    nargs = trigger->tgnargs;
    args = trigger->tgargs;

    if (nargs % 2 != 1) /* odd number of arguments! */
        /* internal error */
        elog(ERROR, "check_primary_key: odd number of arguments should be specified");

    nkeys = nargs / 2;
    relname = args[nkeys];
    rel = trigdata->tg_relation;
    tupdesc = rel->rd_att;

    /* Connect to SPI manager */
    if ((ret = SPI_connect()) < 0)
        /* internal error */
        elog(ERROR, "check_primary_key: SPI_connect returned %d", ret);

    /*
     * We use SPI plan preparation feature, so allocate space to place key
     * values.
     */
    kvals = (Datum*)palloc(nkeys * sizeof(Datum));

    /*
     * Construct ident string as TriggerName $ TriggeredRelationId and try to
     * find prepared execution plan.
     */
    snprintf(ident, sizeof(ident), "%s$%u", trigger->tgname, rel->rd_id);
    plan = find_plan(ident, &g_instance.spi_plan_cxt.PPlans, &g_instance.spi_plan_cxt.nPPlans);

    /* if there is no plan then allocate argtypes for preparation */
    if (plan->nplans <= 0)
        argtypes = (Oid*)palloc(nkeys * sizeof(Oid));

    /* For each column in key ... */
    for (i = 0; i < nkeys; i++) {
        /* get index of column in tuple */
        int fnumber = SPI_fnumber(tupdesc, args[i]);

        /* Bad guys may give us un-existing column in CREATE TRIGGER */
        if (fnumber < 0)
            ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                    errmsg("there is no attribute \"%s\" in relation \"%s\"", args[i], SPI_getrelname(rel))));

        /* Well, get binary (in internal format) value of column */
        kvals[i] = SPI_getbinval(tuple, tupdesc, fnumber, &isnull);

        /*
         * If it's NULL then nothing to do! DON'T FORGET call SPI_finish ()!
         * DON'T FORGET return tuple! Executor inserts tuple you're returning!
         * If you return NULL then nothing will be inserted!
         */
        if (isnull) {
            SPI_finish();
            return PointerGetDatum(tuple);
        }

        if (plan->nplans <= 0) /* Get typeId of column */
            argtypes[i] = SPI_gettypeid(tupdesc, fnumber);
    }

    /*
     * If we have to prepare plan ...
     */
    if (plan->nplans <= 0) {
        SPIPlanPtr pplan;
        char sql[8192];

        /*
         * Construct query: SELECT 1 FROM _referenced_relation_ WHERE Pkey1 =
         * $1 [AND Pkey2 = $2 [...]]
         */
        snprintf(sql, sizeof(sql), "select 1 from %s where ", relname);
        for (i = 0; i < nkeys; i++) {
            snprintf(sql + strlen(sql),
                sizeof(sql) - strlen(sql),
                "%s = $%d %s",
                args[i + nkeys + 1],
                i + 1,
                (i < nkeys - 1) ? "and " : "");
        }

        /* Prepare plan for query */
        pplan = SPI_prepare(sql, nkeys, argtypes);
        if (pplan == NULL)
            /* internal error */
            elog(ERROR, "check_primary_key: SPI_prepare returned %d", SPI_result);

        /*
         * Remember that SPI_prepare places plan in current memory context -
         * so, we have to save plan in Top memory context for later use.
         */
        if (SPI_keepplan(pplan))
            /* internal error */
            elog(ERROR, "check_primary_key: SPI_keepplan failed");

        MemoryContext oldcontext = MemoryContextSwitchTo(g_instance.spi_plan_cxt.global_spi_plan_context);
        plan->splan = (SPIPlanPtr*)palloc(sizeof(SPIPlanPtr));
        (void)MemoryContextSwitchTo(oldcontext);

        if (NULL == plan->splan) {
            ereport(ERROR, (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION), errmsg("out of memory")));
        }

        *(plan->splan) = pplan;
        plan->nplans = 1;
    }

    /*
     * Ok, execute prepared plan.
     */
    ret = SPI_execp(*(plan->splan), kvals, NULL, 1);
    /* we have no NULLs - so we pass   ^^^^   here */

    if (ret < 0)
        /* internal error */
        elog(ERROR, "check_primary_key: SPI_execp returned %d", ret);

    /*
     * If there are no tuples returned by SELECT then ...
     */
    if (SPI_processed == 0)
        ereport(ERROR,
            (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
                errmsg("tuple references non-existent key"),
                errdetail(
                    "Trigger \"%s\" found tuple referencing non-existent key in \"%s\".", trigger->tgname, relname)));

    SPI_finish();

    return PointerGetDatum(tuple);
}

/*
 * check_foreign_key () -- check that key in tuple being deleted/updated
 *			 is not referenced by tuples in "foreign" table(s).
 * Though it's called without args You have to specify (while creating trigger):
 * number of references, action to do if key referenced
 * ('restrict' | 'setnull' | 'cascade'), key field names in triggered
 * ("primary") table and referencing table(s)/keys:
 * EXECUTE PROCEDURE
 * check_foreign_key (2, 'restrict', 'Pkey1', 'Pkey2',
 * 'Ftable1', 'Fkey11', 'Fkey12', 'Ftable2', 'Fkey21', 'Fkey22').
 */

PG_FUNCTION_INFO_V1(check_foreign_key);

Datum check_foreign_key(PG_FUNCTION_ARGS)
{
    TriggerData* trigdata = (TriggerData*)fcinfo->context;
    Trigger* trigger = NULL; /* to get trigger name */
    int nargs;               /* # of args specified in CREATE TRIGGER */
    char** args;             /* arguments: as described above */
    char** args_temp;
    int nrefs;                   /* number of references (== # of plans) */
    char action;                 /* 'R'estrict | 'S'etnull | 'C'ascade */
    int nkeys;                   /* # of key columns */
    Datum* kvals = NULL;         /* key values */
    char* relname = NULL;        /* referencing relation name */
    Relation rel;                /* triggered relation */
    HeapTuple trigtuple = NULL;  /* tuple to being changed */
    HeapTuple newtuple = NULL;   /* tuple to return */
    TupleDesc tupdesc;           /* tuple description */
    EPlanRefInt* plan = NULL;          /* prepared plan(s) */
    Oid* argtypes = NULL;        /* key types to prepare execution plan */
    bool isnull = false;         /* to know is some column NULL or not */
    bool isequal = true;         /* are keys in both tuples equal (in UPDATE) */
    char ident[2 * NAMEDATALEN]; /* to identify myself */
    int is_update = 0;
    int ret;
    int i, r;

#ifdef DEBUG_QUERY
    elog(DEBUG4, "check_foreign_key: Enter Function");
#endif

    /*
     * Some checks first...
     */

    /* Called by trigger manager ? */
    if (!CALLED_AS_TRIGGER(fcinfo))
        /* internal error */
        elog(ERROR, "check_foreign_key: not fired by trigger manager");

    /* Should be called for ROW trigger */
    if (!TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
        /* internal error */
        elog(ERROR, "check_foreign_key: must be fired for row");

    /* Not should be called for INSERT */
    if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
        /* internal error */
        elog(ERROR, "check_foreign_key: cannot process INSERT events");

    /* Have to check tg_trigtuple - tuple being deleted */
    trigtuple = trigdata->tg_trigtuple;

    /*
     * But if this is UPDATE then we have to return tg_newtuple. Also, if key
     * in tg_newtuple is the same as in tg_trigtuple then nothing to do.
     */
    is_update = 0;
    if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event)) {
        newtuple = trigdata->tg_newtuple;
        is_update = 1;
    }
    trigger = trigdata->tg_trigger;
    nargs = trigger->tgnargs;
    args = trigger->tgargs;

    if (nargs < 5) /* nrefs, action, key, Relation, key - at
                    * least */
        /* internal error */
        elog(ERROR, "check_foreign_key: too short %d (< 5) list of arguments", nargs);

    nrefs = pg_strtoint32(args[0]);
    if (nrefs < 1)
        /* internal error */
        elog(ERROR, "check_foreign_key: %d (< 1) number of references specified", nrefs);
    action = tolower((unsigned char)*(args[1]));
    if (action != 'r' && action != 'c' && action != 's')
        /* internal error */
        elog(ERROR, "check_foreign_key: invalid action %s", args[1]);
    nargs -= 2;
    args += 2;
    nkeys = (nargs - nrefs) / (nrefs + 1);
    if (nkeys <= 0 || nargs != (nrefs + nkeys * (nrefs + 1)))
        /* internal error */
        elog(ERROR, "check_foreign_key: invalid number of arguments %d for %d references", nargs + 2, nrefs);

    rel = trigdata->tg_relation;
    tupdesc = rel->rd_att;

    /* Connect to SPI manager */
    if ((ret = SPI_connect()) < 0)
        /* internal error */
        elog(ERROR, "check_foreign_key: SPI_connect returned %d", ret);

    /*
     * We use SPI plan preparation feature, so allocate space to place key
     * values.
     */
    kvals = (Datum*)palloc(nkeys * sizeof(Datum));

    /*
     * Construct ident string as TriggerName $ TriggeredRelationId and try to
     * find prepared execution plan(s).
     */
    snprintf(ident, sizeof(ident), "%s$%u", trigger->tgname, rel->rd_id);
    plan = find_plan(ident, &g_instance.spi_plan_cxt.FPlans, &g_instance.spi_plan_cxt.nFPlans);

    /* if there is no plan(s) then allocate argtypes for preparation */
    if (plan->nplans <= 0)
        argtypes = (Oid*)palloc(nkeys * sizeof(Oid));

    /*
     * else - check that we have exactly nrefs plan(s) ready
     */
    else if (plan->nplans != nrefs)
        /* internal error */
        elog(ERROR, "%s: check_foreign_key: # of plans changed in meantime", trigger->tgname);

    /* For each column in key ... */
    for (i = 0; i < nkeys; i++) {
        /* get index of column in tuple */
        int fnumber = SPI_fnumber(tupdesc, args[i]);

        /* Bad guys may give us un-existing column in CREATE TRIGGER */
        if (fnumber < 0)
            ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_COLUMN),
                    errmsg("there is no attribute \"%s\" in relation \"%s\"", args[i], SPI_getrelname(rel))));

        /* Well, get binary (in internal format) value of column */
        kvals[i] = SPI_getbinval(trigtuple, tupdesc, fnumber, &isnull);

        /*
         * If it's NULL then nothing to do! DON'T FORGET call SPI_finish ()!
         * DON'T FORGET return tuple! Executor inserts tuple you're returning!
         * If you return NULL then nothing will be inserted!
         */
        if (isnull) {
            SPI_finish();
            return PointerGetDatum((newtuple == NULL) ? trigtuple : newtuple);
        }

        /*
         * If UPDATE then get column value from new tuple being inserted and
         * compare is this the same as old one. For the moment we use string
         * presentation of values...
         */
        if (newtuple != NULL) {
            char* oldval = SPI_getvalue(trigtuple, tupdesc, fnumber);
            char* newval = NULL;

            /* this shouldn't happen! SPI_ERROR_NOOUTFUNC ? */
            if (oldval == NULL)
                /* internal error */
                elog(ERROR, "check_foreign_key: SPI_getvalue returned %d", SPI_result);
            newval = SPI_getvalue(newtuple, tupdesc, fnumber);
            if (newval == NULL || strcmp(oldval, newval) != 0)
                isequal = false;
        }

        if (plan->nplans <= 0) /* Get typeId of column */
            argtypes[i] = SPI_gettypeid(tupdesc, fnumber);
    }
    args_temp = args;
    nargs -= nkeys;
    args += nkeys;

    /*
     * If we have to prepare plans ...
     */
    if (plan->nplans <= 0) {
        SPIPlanPtr pplan;
        char sql[8192];
        char** args2 = args;

        plan->splan = (SPIPlanPtr*)malloc(nrefs * sizeof(SPIPlanPtr));

        for (r = 0; r < nrefs; r++) {
            relname = args2[0];

            /*---------
             * For 'R'estrict action we construct SELECT query:
             *
             *	SELECT 1
             *	FROM _referencing_relation_
             *	WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]]
             *
             *	to check is tuple referenced or not.
             *---------
             */
            if (action == 'r')

                snprintf(sql, sizeof(sql), "select 1 from %s where ", relname);

            /*---------
             * For 'C'ascade action we construct DELETE query
             *
             *	DELETE
             *	FROM _referencing_relation_
             *	WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]]
             *
             * to delete all referencing tuples.
             *---------
             */

            /*
             * Max : Cascade with UPDATE query i create update query that
             * updates new key values in referenced tables
             */

            else if (action == 'c') {
                if (is_update == 1) {
                    int fn;
                    char* nv = NULL;
                    int k;

                    snprintf(sql, sizeof(sql), "update %s set ", relname);
                    for (k = 1; k <= nkeys; k++) {
                        int is_char_type = 0;
                        char* type = NULL;

                        fn = SPI_fnumber(tupdesc, args_temp[k - 1]);
                        nv = SPI_getvalue(newtuple, tupdesc, fn);
                        type = SPI_gettype(tupdesc, fn);

                        if ((strcmp(type, "text") && strcmp(type, "varchar") && strcmp(type, "char") &&
                                strcmp(type, "bpchar") && strcmp(type, "date") && strcmp(type, "timestamp")) == 0)
                            is_char_type = 1;
#ifdef DEBUG_QUERY
                        elog(DEBUG4, "check_foreign_key Debug value %s type %s %d", nv, type, is_char_type);
#endif

                        /*
                         * is_char_type =1 i set ' ' for define a new value
                         */
                        snprintf(sql + strlen(sql),
                            sizeof(sql) - strlen(sql),
                            " %s = %s%s%s %s ",
                            args2[k],
                            (is_char_type > 0) ? "'" : "",
                            nv,
                            (is_char_type > 0) ? "'" : "",
                            (k < nkeys) ? ", " : "");
                        is_char_type = 0;
                    }
                    strcat(sql, " where ");

                } else
                    /* DELETE */
                    snprintf(sql, sizeof(sql), "delete from %s where ", relname);

            }

            /*
             * For 'S'etnull action we construct UPDATE query - UPDATE
             * _referencing_relation_ SET Fkey1 null [, Fkey2 null [...]]
             * WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]] - to set key columns in
             * all referencing tuples to NULL.
             */
            else if (action == 's') {
                snprintf(sql, sizeof(sql), "update %s set ", relname);
                for (i = 1; i <= nkeys; i++) {
                    snprintf(
                        sql + strlen(sql), sizeof(sql) - strlen(sql), "%s = null%s", args2[i], (i < nkeys) ? ", " : "");
                }
                strcat(sql, " where ");
            }

            /* Construct WHERE qual */
            for (i = 1; i <= nkeys; i++) {
                snprintf(sql + strlen(sql),
                    sizeof(sql) - strlen(sql),
                    "%s = $%d %s",
                    args2[i],
                    i,
                    (i < nkeys) ? "and " : "");
            }

            /* Prepare plan for query */
            pplan = SPI_prepare(sql, nkeys, argtypes);
            if (pplan == NULL)
                /* internal error */
                elog(ERROR, "check_foreign_key: SPI_prepare returned %d", SPI_result);

            /*
             * Remember that SPI_prepare places plan in current memory context
             * - so, we have to save plan in Top memory context for later use.
             */
            if (SPI_keepplan(pplan))
                /* internal error */
                elog(ERROR, "check_foreign_key: SPI_keepplan failed");

            plan->splan[r] = pplan;

            args2 += nkeys + 1; /* to the next relation */
        }
        plan->nplans = nrefs;
#ifdef DEBUG_QUERY
        elog(DEBUG4, "check_foreign_key Debug Query is :  %s ", sql);
#endif
    }

    /*
     * If UPDATE and key is not changed ...
     */
    if (newtuple != NULL && isequal) {
        SPI_finish();
        return PointerGetDatum(newtuple);
    }

    /*
     * Ok, execute prepared plan(s).
     */
    for (r = 0; r < nrefs; r++) {
        /*
         * For 'R'estrict we may to execute plan for one tuple only, for other
         * actions - for all tuples.
         */
        int tcount = (action == 'r') ? 1 : 0;

        relname = args[0];

        snprintf(ident, sizeof(ident), "%s$%u", trigger->tgname, rel->rd_id);
        plan = find_plan(ident, &g_instance.spi_plan_cxt.FPlans, &g_instance.spi_plan_cxt.nFPlans);
        ret = SPI_execp(plan->splan[r], kvals, NULL, tcount);
        /* we have no NULLs - so we pass   ^^^^  here */

        if (ret < 0)
            ereport(ERROR, (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION), errmsg("SPI_execp returned %d", ret)));

        /* If action is 'R'estrict ... */
        if (action == 'r') {
            /* If there is tuple returned by SELECT then ... */
            if (SPI_processed > 0)
                ereport(ERROR,
                    (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
                        errmsg("\"%s\": tuple is referenced in \"%s\"", trigger->tgname, relname)));
        } else {
#ifdef REFINT_VERBOSE
            elog(NOTICE,
                "%s: %d tuple(s) of %s are %s",
                trigger->tgname,
                SPI_processed,
                relname,
                (action == 'c') ? "deleted" : "set to null");
#endif
        }
        args += nkeys + 1; /* to the next relation */
    }

    SPI_finish();

    return PointerGetDatum((newtuple == NULL) ? trigtuple : newtuple);
}

static EPlanRefInt* find_plan(char* ident, EPlanRefInt** eplan, int* nplans)
{
    EPlanRefInt* newp = NULL;
    int i;

    InitSPIPlanCxt();
    MemoryContext oldcontext = MemoryContextSwitchTo(g_instance.spi_plan_cxt.global_spi_plan_context);

    if (*nplans > 0) {
        for (i = 0; i < *nplans; i++) {
            if (strcmp((*eplan)[i].ident, ident) == 0)
                break;
        }
        if (i != *nplans)
            return (*eplan + i);
        *eplan = (EPlanRefInt*)repalloc(*eplan, (i + 1) * sizeof(EPlanRefInt));
        newp = *eplan + i;
    } else {
        newp = *eplan = (EPlanRefInt*)palloc(sizeof(EPlanRefInt));
        (*nplans) = i = 0;
    }

    if (NULL == newp) {
        ereport(ERROR, (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION), errmsg("out of memory")));
    }

    newp->ident = (char*)palloc(strlen(ident) + 1);
    Assert(NULL != newp->ident);

    strcpy(newp->ident, ident);
    newp->nplans = 0;
    newp->splan = NULL;
    (*nplans)++;

    (void)MemoryContextSwitchTo(oldcontext);

    return (newp);
}
